עקרונות שפות תכנות 2018 תרגול 8 Type Inference System

Transcription

1 עקרונות שפות תכנות 2018 תרגול 8 Type Inference System Type Inference System The Type Inference System is a TypeScript Implementation of the algorithm for Type Checking and Inference using Type Equations. System Architecture The system is built from the following modules: The layers of the system are: - Abstract Syntax for L5 Expressions and for Type Expressions - The key data types manipulated in the algorithm, Type Equations and Type Substitutions. - The logic of the algorithm is implemented in three functional packages: Exp-to-Pool, Exp-to-Equations and the top-level algorithm Solve. The key interfaces of each package are the following: 1

2 Layer 1: Languages Definitions The Type Inference algorithm maps expressions in one language (L5 expressions) into expressions in another language (Type Expressions). The lower level of the Type Inference system implements the Abstract Syntax interfaces for expressions in these two languages. L5-AST: Implements parser and abstract syntax for the following BNF concrete syntax: BNF // <program> ::= (L5 <exp>+) / Program(exps:List(exp)) // <exp> ::= <define> <cexp> / DefExp CExp // <define> ::= ( define <var-decl> <cexp> ) / DefExp(var:VarDecl, val:cexp) // <var> ::= <identifier> / VarRef(var:string) // <cexp> ::= <number> / NumExp(val:number) // <boolean> / BoolExp(val:boolean) // <string> / StrExp(val:string) // <prim-op> / PrimOp(op:string) // <var-ref> // ( lambda ( <var-decl>* ) (: <TExp>)? <cexp>+ ) / ProcExp(params:VarDecl[], body:cexp[], returnte: TExp)) // ( if <cexp> <cexp> <cexp> ) / IfExp(test: CExp, then: CExp, alt: CExp) // ( quote <sexp> ) / LitExp(val:SExp) // ( <cexp> <cexp>* ) / AppExp(operator:CExp, operands:cexp[])) // ( let ( <binding>* ) <cexp>+ ) / LetExp(bindings:Binding[], body:cexp[])) // ( letrec ( binding*) <cexp>+ ) / LetrecExp(bindings:Bindings[], body: CExp) // ( set! <var> <cexp>) / SetExp(var: varref, val: CExp) // <binding> ::= ( <var-decl> <cexp> ) / Binding(var:VarDecl, val:cexp) // <prim-op> ::= + - * / < > = not eq? string=? // cons car cdr list? number? // boolean? symbol? string? // display newline // <num-exp> ::= a number token // <bool-exp> ::= #t #f // <var-ref> ::= an identifier token / VarRef(var) // <var-decl> ::= an identifier token (var : TExp) / VarRef(var, TE: TExp) // <sexp> ::= symbol number bool string ( <sexp>* ) Note that we introduce optional type annotations in the L5 syntax in 2 places only: - As part of VarDecl in the form (var : type-expression) - As part of ProcExp in the return type of the procedure in the form: (lambda ((x : number) (y : number)) : number ) TExp-AST // Type language // <TExp> ::= <AtomicTExp> <CompoundTExp> <TVar> // <AtomicTExp> ::= <NumTExp> <BoolTExp> <StrTExp> <VoidTExp> // <NumTExp> ::= number // NumTExp() // <BoolTExp> ::= boolean // BoolTExp() // <StrTExp> ::= string // StrTExp() // <VoidTExp> ::= void // VoidTExp() // <CompoundTExp> ::= <ProcTExp> <TupleTExp> 2

3 // <NonTupleTExp> ::= <AtomicTExp> <ProcTExp> <TVar> // <ProcTExp> ::= [ <TupleTExp> -> <NonTupleTExp> ] // ProcTExp(param-tes: list(texp), returnte: TExp) // <TupleTExp> ::= <NonEmptyTupleTExp> <EmptyTExp> // <NonEmptyTupleTExp> ::= ( <NonTupleTExp> * )* <NonTupleTExp> // TupleTExp(tes: list(texp)) // <EmptyTExp> ::= empty // <TVar> ::= a symbol starting with T // TVar(id: Symbol, contents; Box(string undefined)) Examples of type expressions // number // boolean // void // (number -> boolean) // (number * number -> boolean) // (number -> (number -> boolean)) // (empty -> number) // (empty -> void) The definition of the TExp datatypes, the parser and the unparser of TExp is provided in file TExp.ts. Layer 2: Substitution and Equation ADTs The Type Inference algorithm is defined in terms of 2 basic formal tools: Type Substitutions are finite mappings of Type Variables to Type Expressions. Equations are pairs that state that a left Type Expression is to be held equivalent to a right Type Expression. Equations are the tool we use to represent a typing statement in the algorithm. Substitution ADT The interface of the Substitution ADT includes: makesub(variables, type-expressions) subget(sub, var): lookup a variable in a substitution extendsub(sub, var, te): create a new substitution by adding a single pair {var:te} to sub applysub(sub, te): replace type variables inside te according to sub combinesub(sub1, sub2): compute a new sub such that: applysub(sub, te) = applysub(sub2, applysub(sub1, te)) for all te. Equation ADT The interface includes: export interface Equation {left: T.TExp, right: T.TExp}; export const makeequation = (l: T.TExp, r: T.TExp): Equation => ({left: l, right: r}); 3

4 Layer 3: Exp-to-Pool, Exp-to-Equations, Solve exptopool(exp) traverses the AST of a Scheme Expression and maps each sub-expression in the AST to distinct Type Variables. pooltoequations(pool) applies type formulae to propagate constraints from the syntactic structure of the L5 Expression to constraints (equations) among the type variables of the pool. There are specific constraints derived for each type of syntactic construct according to the semantics of the L5 programming language. infer(l5expr) applies the whole logic of the type inference algorithm. The main steps of the algorithm are reflected in this top-level fragment: export const infertype = (exp: A.Exp): T.TExp => { const pool = exptopool(exp); const equations = pooltoequations(pool); const sub = solveequations(equations); const texp = inpool(pool, exp); if (T.isTVar(texp) &&! iserror(sub)) return S.subGet(sub, texp); else return texp; } The key logic of the algorithm lies in the solveequations algorithm which turns a list of Type Equations into a single coherent Type Substitution which satisfies all the constraints. solveequations() relies on the computation of unification between two type expressions as shown in the following fragment: // Purpose: Solve the type equations and return the resulting substitution // or error, if not solvable // Example: solveequations( // pooltoequations( // exptopool( // parse('((lambda (x) (x 11)) (lambda (y) y))')))) => sub export const solveequations = (equations: Equation[]): S.Sub Error => solve(equations, S.makeEmptySub()); // Purpose: Solve the equations, starting from a given substitution. // Returns the resulting substitution, or error, if not solvable const solve = (equations: Equation[], sub: S.Sub): S.Sub Error => { const solvevareq = (tvar: T.TVar, texp: T.TExp): S.Sub Error => { const sub2 = S.extendSub(sub, tvar, texp); return iserror(sub2)? sub2 : solve(rest(equations), sub2); }; const bothsidesatomic = (eq: Equation): boolean => T.isAtomicTExp(eq.left) && T.isAtomicTExp(eq.right); const handlebothsidesatomic = (eq: Equation): S.Sub Error => (T.isAtomicTExp(eq.left) && T.isAtomicTExp(eq.right) && T.eqAtomicTExp(eq.left, eq.right))? solve(rest(equations), sub) : Error(`Equation with non-equal atomic type ${eq}`); 4

5 } if (A.isEmpty(equations)) return sub; const eq = makeequation(s.applysub(sub, first(equations).left), S.applySub(sub, first(equations).right)); return T.isTVar(eq.left)? solvevareq(eq.left, eq.right) : T.isTVar(eq.right)? solvevareq(eq.right, eq.left) : bothsidesatomic(eq)? handlebothsidesatomic(eq) : (T.isCompoundTExp(eq.left) && T.isCompoundTExp(eq.right) && canunify(eq))? solve(r.concat(rest(equations), splitequation(eq)), sub) : Error(`Equation contains incompatible types ${eq}`); Compound type expressions are unified by unifying their components one by one. This is implemented by these 2 functions: // Signature: canunify(equation) // Purpose: Compare the structure of the type expressions of the equation const canunify = (eq: Equation): boolean => T.isProcTExp(eq.left) && T.isProcTExp(eq.right) && (eq.left.paramtes.length === eq.right.paramtes.length); // Signature: splitequation(equation) // Purpose: For an equation with unifyable type expressions, // create equations for corresponding components. // Type: [Equation -> List(Equation)] // Example: splitequation( // makeequation(parsetexp('(t1 -> T2)'), // parsetexp('(t3 -> (T4 -> T4))')) => // [ {left:t2, right: (T4 -> T4)}, // {left:t3, right: T1)} ] iscompoundexp(eq.left) && iscompoundexp(eq.right) && canunify(eq) const splitequation = (eq: Equation): Equation[] => (T.isProcTExp(eq.left) && T.isProcTExp(eq.right))? R.zipWith(makeEquation, R.prepend(eq.left.returnTE, eq.left.paramtes), R.prepend(eq.right.returnTE, eq.right.paramtes)) : []; 5

6 Exercise: Extend the Type Inference system to support "If" expressions The part of the Type Inference System which "knows" L5 Expressions is the function makeequationfromexp(exp, pool). The structure of this function is a case for each type of L5 expression. The code we provide supports: Procedure Application Number and Boolean Primitive Procedures Extend the code to support Scheme expressions of the type (if <test> <then> <alt>). Remember question 2 from last week's practical session. From Typing Rule for if-expressions the type equations derived from a composite if-expression: (if _p _c _a) we derive 3 equations: T c = T a T p = boolean T if = T c Accordingly, the code of the function makeequationfromexp is extended to process IfExp // Support if-expressions: // [if <test> <then> <else>) --> // {[T<test> = boolean], [T<then> = T<alt>], [T<then> = T<if>]} A.isIfExp(exp)? [makeequation(inpool(pool, exp.test), T.makeBoolTExp()), makeequation(inpool(pool, exp.then), inpool(pool, exp.alt)), makeequation(inpool(pool, exp), inpool(exp.alt))] : Review the code of the AppExp equation factory: // An application must respect the type of its operator // Type(Operator) = [T1 *.. * Tn -> Te] // Type(Application) = Te A.isAppExp(exp)? [makeequation(inpool(pool, exp.rator), T.makeProcTExp(R.map((e) => inpool(pool, e), exp.rands), inpool(pool, exp)))] : This should create one equation for each argument and one equation for the exp itself. Explain why it is not necessary to add an equation for the type of the exp itself. 6

7 // Implementation of the Substitution ADT // ======================================================== // A substitution is represented as a 2 element list of equal length // lists of variables and type expression. // The empty substitution is [[], []] export interface Sub {tag: "Sub"; vars: TVar[]; tes: TExp[]; }; export const issub = (x: any): x is Sub => x.tag === "Sub";.substitution עבור ADT נספח לעיון // Constructors: // Signature: makesub(vars, tes) // Purpose: Create a substitution in which the i-th element of 'variables' // is mapped to the i-th element of 'tes'. // Example: makesub( // map(parsete, ["x", "y", "z"]), // map(parsete, ["number", "boolean", "(number -> number)"]) // => {tag: "Sub", vars: [x y z], // tes: [numtexp, booltexp, ProcTexp([NumTexp, NumTexp])]} // makesub(map(parsete, ["x", "y", "z"]), // map(parsete, ["number", "boolean", "(z -> number)"])) // => error makesub: circular substitution // Pre-condition: (length variables) = (length tes) // the list variables has no repetitions (it is a set) export const makesub = (vars: TVar[], tes: TExp[]): Error Sub => { const nooccurrences = zipwith(checknooccurrence, vars, tes); if (hasnoerror(nooccurrences)) return {tag: "Sub", vars: vars, tes: tes}; else return Error(getErrorMessages(noOccurrences)); }; export const makeemptysub = (): Sub => ({tag: "Sub", vars: [], tes: []}); Whenever creating a substitution, we verify that the invariant holds that when a TVar is associated to a TExp, it does not occur inside the TExp. This is enforced by this function: // Purpose: when attempting to bind tvar to te in a sub - check whether tvar occurs in te. // Return error if a circular reference is found. export const checknooccurrence = (tvar: TVar, te: TExp): true Error => { const check = (e: TExp): true Error => istvar(e)? ((e.var === tvar.var)? Error(`Occur check error - circular sub ${tvar.var} in ${unparsetexp(te)}`) : true) : isatomictexp(e)? true : isproctexp(e)? (hasnoerror(map(check, e.paramtes))? check(e.returnte) : Error(getErrorMessages(map(check, e.paramtes)))) : Error(`Bad type expression ${e} in ${te}`); return check(te); }; 7

8 Note on how we compare two substitutions to perform tests In order to compare two substitutions, we normalize them by sorting their string representation and then compare the strings. This in effect achieves set equality: export const subtostr = (sub: S.Sub): string => `{${zipwith((v, t) => `${v.var}:${unparsetexp(t)}`, sub.vars, sub.tes). sort(). join(", ")}}`; // Compare 2 subs encoded as VarTe (set equality) export const eqsub = (sub1: S.Sub, sub2: S.Sub): boolean => deepequal(subtostr(sub1), subtostr(sub2)); Understand how to use applysub From L5-substitutions-ADT-tests.ts: // applysub { const sub1 = sub(["t1", "T2"], ["number", "boolean"]); const te1 = parsete("(t1 * T2 -> T1)"); if (! iserror(te1)) { const te2 = S.applySub(sub1, te1); assert(unparsetexp(te2) === "(number * boolean -> number)"); } } Understand how to use combinesub // {T1:(number -> S1), T2:(number -> S4)} o {T3:(number -> S2)} => // {T1:(number -> S1), T2:(number -> S4), T3:(number -> S2)} { const sub1 = sub(["t1", "T2"], ["(number -> S1)", "(number -> S4)"]); const sub2 = sub(["t3"], ["(number -> S2)"]); const expected = sub(["t1", "T2", "T3"], ["(number -> S1)", "(number -> S4)", "(number -> S2)"]); const res = S.combineSub(sub1, sub2); asserteqsub(res, expected); } 8